<!doctype html>



  


<html class="theme-next pisces use-motion">
<head>
<!-- Google Tag Manager -->
<script>(function(w,d,s,l,i){w[l]=w[l]||[];w[l].push({'gtm.start':
new Date().getTime(),event:'gtm.js'});var f=d.getElementsByTagName(s)[0],
j=d.createElement(s),dl=l!='dataLayer'?'&l='+l:'';j.async=true;j.src=
'https://www.googletagmanager.com/gtm.js?id='+i+dl;f.parentNode.insertBefore(j,f);
})(window,document,'script','dataLayer','GTM-PBHRK7');</script>
<!-- End Google Tag Manager -->
  <meta charset="UTF-8"/>
<meta http-equiv="X-UA-Compatible" content="IE=edge,chrome=1" />
<meta name="viewport" content="width=device-width, initial-scale=1, maximum-scale=1"/>



<meta http-equiv="Cache-Control" content="no-transform" />
<meta http-equiv="Cache-Control" content="no-siteapp" />












  
  
  <link href="/lib/fancybox/source/jquery.fancybox.css?v=2.1.5" rel="stylesheet" type="text/css" />




  
  
  
  

  
    
    
  

  

  

  

  

  
    
    
    <link href="//fonts.googleapis.com/css?family=Lato:300,300italic,400,400italic,700,700italic&subset=latin,latin-ext" rel="stylesheet" type="text/css">
  






<link href="/lib/font-awesome/css/font-awesome.min.css?v=4.4.0" rel="stylesheet" type="text/css" />

<link href="/css/main.css?v=5.0.2" rel="stylesheet" type="text/css" />


  <meta name="keywords" content="前端 知识 面试," />








  <link rel="shortcut icon" type="image/x-icon" href="/favicon.ico?v=5.0.2" />






<meta name="description" content="Node是搞后端的，不应该被被归为前端，更不应该用前端的观点去理解，去面试node开发人员。所以这份面试题大全，更侧重后端应用与对Node核心的理解。 github地址: https://github.com/jimuyouyou/node-interview-questions 注: 这是本人历时一星期完成的小作品，github里面对一些关键代码还有js源文件．直接node filename.j">
<meta name="keywords" content="前端 知识 面试">
<meta property="og:type" content="article">
<meta property="og:title" content="前端面试《第十二篇》侧重后端应用与对Node核心的理解">
<meta property="og:url" content="http://wurh.github.io/2019/03/31/201903311151/index.html">
<meta property="og:site_name" content="华Ing&#39;s blog">
<meta property="og:description" content="Node是搞后端的，不应该被被归为前端，更不应该用前端的观点去理解，去面试node开发人员。所以这份面试题大全，更侧重后端应用与对Node核心的理解。 github地址: https://github.com/jimuyouyou/node-interview-questions 注: 这是本人历时一星期完成的小作品，github里面对一些关键代码还有js源文件．直接node filename.j">
<meta property="og:locale" content="en">
<meta property="og:image" content="https://github.com/jimuyouyou/node-interview-questions/raw/master/node_skillset.jpg">
<meta property="og:image" content="https://camo.githubusercontent.com/233315761d49d4c75fe7969e36bda22ecf5bbc0f/687474703a2f2f6a6f616f7073696c76612e6769746875622e696f2f74616c6b732f456e642d746f2d456e642d4a6176615363726970742d776974682d7468652d4d45414e2d537461636b2f696d672f6e6f64656a732d617263682d7070742e706e67">
<meta property="og:updated_time" content="2019-07-12T06:10:38.188Z">
<meta name="twitter:card" content="summary">
<meta name="twitter:title" content="前端面试《第十二篇》侧重后端应用与对Node核心的理解">
<meta name="twitter:description" content="Node是搞后端的，不应该被被归为前端，更不应该用前端的观点去理解，去面试node开发人员。所以这份面试题大全，更侧重后端应用与对Node核心的理解。 github地址: https://github.com/jimuyouyou/node-interview-questions 注: 这是本人历时一星期完成的小作品，github里面对一些关键代码还有js源文件．直接node filename.j">
<meta name="twitter:image" content="https://github.com/jimuyouyou/node-interview-questions/raw/master/node_skillset.jpg">



<script type="text/javascript" id="hexo.configuration">
  var NexT = window.NexT || {};
  var CONFIG = {
    scheme: 'Pisces',
    sidebar: {"position":"left","display":"post"},
    fancybox: true,
    motion: true,
    duoshuo: {
      userId: '0',
      author: 'Author'
    }
  };
</script>




  <link rel="canonical" href="http://wurh.github.io/2019/03/31/201903311151/"/>


  <title> 前端面试《第十二篇》侧重后端应用与对Node核心的理解 | 华Ing's blog </title>
</head>

<body itemscope itemtype="//schema.org/WebPage" lang="en">
<!-- Google Tag Manager (noscript) -->
<noscript><iframe src="https://www.googletagmanager.com/ns.html?id=GTM-PBHRK7"
height="0" width="0" style="display:none;visibility:hidden"></iframe></noscript>
<!-- End Google Tag Manager (noscript) -->

  










  
  
    
  

<script>
  (function(i,s,o,g,r,a,m){i['GoogleAnalyticsObject']=r;i[r]=i[r]||function(){
  (i[r].q=i[r].q||[]).push(arguments)},i[r].l=1*new Date();a=s.createElement(o),
  m=s.getElementsByTagName(o)[0];a.async=1;a.src=g;m.parentNode.insertBefore(a,m)
  })(window,document,'script','https://www.google-analytics.com/analytics.js','ga');

  ga('create', 'UA-69412379-1', 'auto');
  ga('send', 'pageview');

</script>

  <script>
  var _hmt = _hmt || [];
  (function() {
    var hm = document.createElement("script");
    hm.src = "https://hm.baidu.com/hm.js?b3ddfb8655d8b77429e04c7a4d5bcbc1";
    var s = document.getElementsByTagName("script")[0];
    s.parentNode.insertBefore(hm, s);
  })();
  </script>


  <div class="container one-collumn sidebar-position-left page-post-detail ">
    <div class="headband"></div>

    <header id="header" class="header" itemscope itemtype="//schema.org/WPHeader">
      <div class="header-inner"><div class="site-meta ">
  

  <div class="custom-logo-site-title">
    <a href="/"  class="brand" rel="start">
      <span class="logo-line-before"><i></i></span>
      <span class="site-title">华Ing's blog</span>
      <span class="logo-line-after"><i></i></span>
    </a>
  </div>
  <p class="site-subtitle">harder and harder</p>
</div>

<div class="site-nav-toggle">
  <button>
    <span class="btn-bar"></span>
    <span class="btn-bar"></span>
    <span class="btn-bar"></span>
  </button>
</div>

<nav class="site-nav">
  

  
    <ul id="menu" class="menu">
      
        
        <li class="menu-item menu-item-home">
          <a href="/" rel="section">
            
            Home
          </a>
        </li>
      
        
        <li class="menu-item menu-item-categories">
          <a href="/categories" rel="section">
            
            Categories
          </a>
        </li>
      
        
        <li class="menu-item menu-item-archives">
          <a href="/archives" rel="section">
            
            Archives
          </a>
        </li>
      
        
        <li class="menu-item menu-item-tags">
          <a href="/tags" rel="section">
            
            Tags
          </a>
        </li>
      

      
    </ul>
  

  
</nav>

 </div>
    </header>

    <main id="main" class="main">
      <div class="main-inner">
        <div class="content-wrap">
          <div id="content" class="content">
            

  <div id="posts" class="posts-expand">
    

  
  

  
  
  

  <article class="post post-type-normal " itemscope itemtype="//schema.org/Article">

    
      <header class="post-header">

        
        
          <h1 class="post-title" itemprop="name headline">
            
            
              
                前端面试《第十二篇》侧重后端应用与对Node核心的理解
              
            
          </h1>
        

        <div class="post-meta">
          <span class="post-time">
            <span class="post-meta-item-icon">
              <i class="fa fa-calendar-o"></i>
            </span>
            <span class="post-meta-item-text">Posted on</span>
            <time itemprop="dateCreated" datetime="2019-03-31T13:30:12+08:00" content="2019-03-31">
              2019-03-31
            </time>
          </span>

          
            <span class="post-category" >
              &nbsp; | &nbsp;
              <span class="post-meta-item-icon">
                <i class="fa fa-folder-o"></i>
              </span>
              <span class="post-meta-item-text">In</span>
              
                <span itemprop="about" itemscope itemtype="https://schema.org/Thing">
                  <a href="/categories/前端面试/" itemprop="url" rel="index">
                    <span itemprop="name">前端面试</span>
                  </a>
                </span>

                
                

              
            </span>
          

          
            
              <span class="post-comments-count">
                &nbsp; | &nbsp;
                <a href="/2019/03/31/201903311151/#comments" itemprop="discussionUrl">
                  <span class="post-comments-count ds-thread-count" data-thread-key="2019/03/31/201903311151/" itemprop="commentsCount"></span>
                </a>
              </span>
            
          

          

          
          

          
        </div>
      </header>
    


    <div class="post-body" itemprop="articleBody">

      
      

      
        <p><strong>Node是搞后端的，不应该被被归为前端，更不应该用前端的观点去理解，去面试node开发人员。所以这份面试题大全，更侧重后端应用与对Node核心的理解。</strong></p>
<p>github地址: <a href="https://github.com/jimuyouyou/node-interview-questions" target="_blank" rel="noopener">https://github.com/jimuyouyou/node-interview-questions</a></p>
<p>注: 这是本人历时一星期完成的小作品，github里面对一些关键代码还有js源文件．直接node filename.js就可查看效果．</p>
<pre><code>**第一个版本，写的匆忙，能力有限，欢迎拍砖补充！**后面持续更新会及时发布到github上.
</code></pre><p><a href="https://github.com/jimuyouyou/node-interview-questions#node开发技能图解" target="_blank" rel="noopener"></a></p>
<h1 id="node开发技能图解"><a href="#node开发技能图解" class="headerlink" title="node开发技能图解"></a>node开发技能图解</h1><p><img src="https://github.com/jimuyouyou/node-interview-questions/raw/master/node_skillset.jpg" alt=""></p>
<h1 id="起源"><a href="#起源" class="headerlink" title="起源"></a><a href="https://github.com/jimuyouyou/node-interview-questions#起源" target="_blank" rel="noopener"></a>起源</h1><ul>
<li>node正风生火起，很多介绍却停留在入门阶段，无法投入生产</li>
<li>node相关的高质量面试题更是少之又少，很难全面考查应聘者的node能力</li>
<li>许多文章在讲第三方类库，可是这些库质量差距较大，一旦遇到问题怎么办</li>
<li>必需的，全面了解node核心才能成为一名合格的node开发人员</li>
</ul>
<h1 id="目标与原则"><a href="#目标与原则" class="headerlink" title="目标与原则"></a><a href="https://github.com/jimuyouyou/node-interview-questions#目标与原则" target="_blank" rel="noopener"></a>目标与原则</h1><ul>
<li>前后端兼顾，更侧重后端</li>
<li>理论实战兼顾，侧重考察对实战中应用较多的理论的理解</li>
<li>参考答案简单明了，一针见血，不为追求严谨而浪费口舌，绕弯子</li>
<li>尽量用代码讲清理论的应用与区别，以接地气</li>
<li>终极目标是让大家对node有一个快速完整的认识</li>
</ul>
<h1 id="内容大纲"><a href="#内容大纲" class="headerlink" title="内容大纲"></a><a href="https://github.com/jimuyouyou/node-interview-questions#内容大纲" target="_blank" rel="noopener"></a>内容大纲</h1><ul>
<li><a href="https://github.com/jimuyouyou/node-interview-questions#jsAdvanced" target="_blank" rel="noopener">javascript高级话题(面向对象，作用域，闭包，设计模式等)</a></li>
<li><a href="https://github.com/jimuyouyou/node-interview-questions#nodeCore" target="_blank" rel="noopener">node核心内置类库(事件，流，文件，网络等)</a></li>
<li><a href="https://github.com/jimuyouyou/node-interview-questions#nodeAdvanced" target="_blank" rel="noopener">node高级话题(异步，部署，性能调优，异常调试等)</a></li>
<li><a href="https://github.com/jimuyouyou/node-interview-questions#node3rd" target="_blank" rel="noopener">常用知名第三方类库(Async, Express等)</a></li>
<li><a href="https://github.com/jimuyouyou/node-interview-questions#otherBackend" target="_blank" rel="noopener">其它相关后端常用技术(MongoDB, Redis, Apache, Nginx等)</a></li>
<li><a href="https://github.com/jimuyouyou/node-interview-questions#otherFrontEnd" target="_blank" rel="noopener">常用前端技术(Html5, CSS3, JQuery等)</a></li>
</ul>
<h2 id="javascript高级话题-面向对象，作用域，闭包，设计模式等"><a href="#javascript高级话题-面向对象，作用域，闭包，设计模式等" class="headerlink" title="javascript高级话题(面向对象，作用域，闭包，设计模式等)"></a><a href="https://github.com/jimuyouyou/node-interview-questions#javascript高级话题面向对象作用域闭包设计模式等" target="_blank" rel="noopener"></a>javascript高级话题(面向对象，作用域，闭包，设计模式等)</h2><ul>
<li><strong>1. 常用js类定义的方法有哪些？</strong></li>
</ul>
<p>参考答案：主要有构造函数原型和对象创建两种方法。原型法是通用老方法，对象创建是ES5推荐使用的方法.目前来看，原型法更普遍.</p>
<p>代码演示<br>1) 构造函数方法定义类</p>
<pre><code>function Person(){
    this.name = &apos;michaelqin&apos;;
}
Person.prototype.sayName = function(){
    alert(this.name);
}

var person = new Person();
person.sayName();
</code></pre><p>2) 对象创建方法定义类</p>
<pre><code>var Person = {
    name: &apos;michaelqin&apos;,
    sayName: function(){ alert(this.name); }
};

var person = Object.create(Person);
person.sayName();
</code></pre><ul>
<li><strong>2. js类继承的方法有哪些</strong></li>
</ul>
<p>参考答案：原型链法，属性复制法和构造器应用法. 另外，由于每个对象可以是一个类，这些方法也可以用于对象类的继承．</p>
<p>代码演示<br>1) 原型链法</p>
<pre><code>function Animal() {
    this.name = &apos;animal&apos;;
}
Animal.prototype.sayName = {
    alert(this.name);
};

function Person() {}
Person.prototype = Animal.prototype; // 人继承自动物
Person.prototype.constructor = &apos;Person&apos;; // 更新构造函数为人
</code></pre><p>2) 属性自制法</p>
<pre><code>function Animal() {
    this.name = &apos;animal&apos;;
}
Animal.prototype.sayName = {
    alert(this.name);
};

function Person() {}

for(prop in Animal.prototype) {
    Person.prototype\[prop\] = Animal.prototype\[prop\];
} // 复制动物的所有属性到人量边
Person.prototype.constructor = &apos;Person&apos;; // 更新构造函数为人
</code></pre><p>3) 构造器应用法</p>
<pre><code>function Animal() {
    this.name = &apos;animal&apos;;
}
Animal.prototype.sayName = {
    alert(this.name);
};

function Person() {
    Animal.call(this); // apply, call, bind方法都可以．细微区别，后面会提到．
}
</code></pre><ul>
<li><strong>3. js类多重继承的实现方法是怎么样的?</strong></li>
</ul>
<p>参考答案：就是类继承里边的属性复制法来实现．因为当所有父类的prototype属性被复制后，子类自然拥有类似行为和属性．</p>
<ul>
<li><strong>4. js里的作用域是什么样子的？</strong></li>
</ul>
<p>参考答案：大多数语言里边都是块作作用域，以{}进行限定，js里边不是．js里边叫函数作用域，就是一个变量在全函数里有效．比如有个变量p1在函数最后一行定义，第一行也有效，但是值是undefined.</p>
<p>代码演示</p>
<pre><code>var globalVar = &apos;global var&apos;;

function test() {
    alert(globalVar); // undefined, 因为globalVar在本函数内被重定义了，导致全局失效，这里使用函数内的变量值，可是此时还没定义
    var globalVar = &apos;overrided var&apos;; //　globalVar在本函数内被重定义
    alert(globalVar);　// overrided var
}
alert(globalVar); // global var，使用全局变量
</code></pre><ul>
<li><strong>5. js里边的this指的是什么?</strong></li>
</ul>
<p>参考答案: this指的是对象本身，而不是构造函数．</p>
<p>代码演示</p>
<pre><code>function Person() {
}
Person.prototype.sayName() { alert(this.name); }

var person1 = new Person();
person1.name = &apos;michaelqin&apos;;
person1.sayName(); // michaelqin
</code></pre><ul>
<li><strong>6. apply, call和bind有什么区别?</strong></li>
</ul>
<p>参考答案：三者都可以把一个函数应用到其他对象上，注意不是自身对象．apply,call是直接执行函数调用，bind是绑定，执行需要再次调用．apply和call的区别是apply接受数组作为参数，而call是接受逗号分隔的无限多个参数列表，</p>
<p>代码演示</p>
<pre><code>function Person() {
}
Person.prototype.sayName() { alert(this.name); }

var obj = {name: &apos;michaelqin&apos;}; // 注意这是一个普通对象，它不是Person的实例
1) apply
Person.prototype.sayName.apply(obj, \[param1, param2, param3\]);

2) call
Person.prototype.sayName.call(obj, param1, param2, param3);

3) bind
var sn = Person.prototype.sayName.bind(obj);    
sn(\[param1, param2, param3\]); // bind需要先绑定，再执行 
sn(param1, param2, param3); // bind需要先绑定，再执行
</code></pre><ul>
<li><strong>7. caller, callee和arguments分别是什么?</strong></li>
</ul>
<p>参考答案: caller,callee之间的关系就像是employer和employee之间的关系，就是调用与被调用的关系，二者返回的都是函数对象引用．arguments是函数的所有参数列表，它是一个类数组的变量．</p>
<p>代码演示</p>
<pre><code>function parent(param1, param2, param3) {
    child(param1, param2, param3);
}

function child() {
    console.log(arguments); // { &apos;0&apos;: &apos;mqin1&apos;, &apos;1&apos;: &apos;mqin2&apos;, &apos;2&apos;: &apos;mqin3&apos; }
    console.log(arguments.callee); // \[Function: child\]
    console.log(child.caller); // \[Function: parent\]
}

parent(&apos;mqin1&apos;, &apos;mqin2&apos;, &apos;mqin3&apos;);
</code></pre><ul>
<li><strong>8. 什么是闭包，闭包有哪些用处?</strong></li>
</ul>
<p>参考答案: 闭包这个术语，无论中文翻译还是英文解释都太２Ｂ了，我必须骂人，因为它什么其实都不是．非要讲它是什么的话，两个字函数，更多字嵌套函数的父子自我引用关系．所有函数都是闭包．通俗的说，闭包就是作用域范围，因为js是函数作用域，所以函数就是闭包．全局函数的作用域范围就是全局，所以无须讨论．更多的应用其实是在内嵌函数，这就会涉及到内嵌作用域，或者叫作用域链．说到内嵌，其实就是父子引用关系(父函数包含子函数，子函数因为函数作用域又引用父函数，这它妈不是死结吗？所以叫闭包），这就会带来另外一个问题，什么时候引用结束？如果不结束，就会一直占用内存，引起内存泄漏．好吧，不用的时候就引用设为空，死结就解开了．</p>
<ul>
<li><strong>9. defineProperty, hasOwnProperty, isEnumerable都是做什么用的？</strong></li>
</ul>
<p>参考答案：Object.defineProperty(obj, prop, descriptor)用来给对象定义属性,有value,writable,configurable,enumerable,set/get等.hasOwnProerty用于检查某一属性是不是存在于对象本身，继承来的父亲的属性不算．isEnumerable用来检测某一属性是否可遍历，也就是能不能用for..in循环来取到.</p>
<ul>
<li><strong>10. js常用设计模式的实现思路，单例，工厂，代理，装饰，观察者模式等</strong></li>
</ul>
<p>参考答案：</p>
<pre><code>1) 单例：　任意对象都是单例，无须特别处理
var obj = {name: &apos;michaelqin&apos;, age: 30};

2) 工厂: 就是同样形式参数返回不同的实例
function Person() { this.name = &apos;Person1&apos;; }
function Animal() { this.name = &apos;Animal1&apos;; }

function Factory() {}
Factory.prototype.getInstance = function(className) {
    return eval(&apos;new &apos; \+ className \+ &apos;()&apos;);
}

var factory = new Factory();
var obj1 = factory.getInstance(&apos;Person&apos;);
var obj2 = factory.getInstance(&apos;Animal&apos;);
console.log(obj1.name); // Person1
console.log(obj2.name); // Animal1

3) 代理: 就是新建个类调用老类的接口,包一下
function Person() { }
Person.prototype.sayName = function() { console.log(&apos;michaelqin&apos;); }
Person.prototype.sayAge = function() { console.log(30); }

function PersonProxy() { 
    this.person = new Person();
    var that = this;
    this.callMethod = function(functionName) {
        console.log(&apos;before proxy:&apos;, functionName);
        that.person\[functionName\](); // 代理
        console.log(&apos;after proxy:&apos;, functionName);
    }
}

var pp = new PersonProxy();
pp.callMethod(&apos;sayName&apos;); // 代理调用Person的方法sayName()
pp.callMethod(&apos;sayAge&apos;); // 代理调用Person的方法sayAge() 

4) 观察者: 就是事件模式，比如按钮的onclick这样的应用.
function Publisher() {
    this.listeners = \[\];
}
Publisher.prototype = {
    &apos;addListener&apos;: function(listener) {
        this.listeners.push(listener);
    },

    &apos;removeListener&apos;: function(listener) {
        delete this.listeners\[listener\];
    },

    &apos;notify&apos;: function(obj) {
        for(var i = 0; i &lt; this.listeners.length; i++) {
            var listener = this.listeners\[i\];
            if (typeof listener !== &apos;undefined&apos;) {
                listener.process(obj);
            }
        }
    }
}; // 发布者

function Subscriber() {

}
Subscriber.prototype = {
    &apos;process&apos;: function(obj) {
        console.log(obj);
    }
};　// 订阅者


var publisher = new Publisher();
publisher.addListener(new Subscriber());
publisher.addListener(new Subscriber());
publisher.notify({name: &apos;michaelqin&apos;, ageo: 30}); // 发布一个对象到所有订阅者
publisher.notify(&apos;2 subscribers will both perform process&apos;); // 发布一个字符串到所有订阅者
</code></pre><ul>
<li><strong>11. 列举数组相关的常用方法</strong></li>
</ul>
<p>参考答案: push/pop, shift/unshift, split/join, slice/splice/concat, sort/reverse, map/reduce, forEach, filter</p>
<ul>
<li><strong>12. 列举字符串相关的常用方法</strong></li>
</ul>
<p>参考答案: indexOf/lastIndexOf/charAt, split/match/test, slice/substring/substr, toLowerCase/toUpperCase</p>
<h2 id="node核心内置类库-事件，流，文件，网络等"><a href="#node核心内置类库-事件，流，文件，网络等" class="headerlink" title="node核心内置类库(事件，流，文件，网络等)"></a><a href="https://github.com/jimuyouyou/node-interview-questions#node核心内置类库事件流文件网络等" target="_blank" rel="noopener"></a>node核心内置类库(事件，流，文件，网络等)</h2><h3 id="node概览"><a href="#node概览" class="headerlink" title="node概览"></a><a href="https://github.com/jimuyouyou/node-interview-questions#node概览" target="_blank" rel="noopener"></a>node概览</h3><ul>
<li><strong>1. 为什么要用node?</strong></li>
</ul>
<p>参考答案: 总结起来node有以下几个特点:简单强大，轻量可扩展．简单体现在node使用的是javascript,json来进行编码，人人都会；强大体现在非阻塞IO,可以适应分块传输数据，较慢的网络环境，尤其擅长高并发访问；轻量体现在node本身既是代码，又是服务器，前后端使用统一语言;可扩展体现在可以轻松应对多实例，多服务器架构，同时有海量的第三方应用组件．</p>
<ul>
<li><strong>2. node的构架是什么样子的?</strong></li>
</ul>
<p>参考答案: 主要分为三层，应用app &gt;&gt; V8及node内置架构 &gt;&gt; 操作系统. V8是node运行的环境，可以理解为node虚拟机．node内置架构又可分为三层: 核心模块(javascript实现) &gt;&gt; c++绑定 &gt;&gt; libuv + CAes + http.</p>
<p><a href="https://camo.githubusercontent.com/233315761d49d4c75fe7969e36bda22ecf5bbc0f/687474703a2f2f6a6f616f7073696c76612e6769746875622e696f2f74616c6b732f456e642d746f2d456e642d4a6176615363726970742d776974682d7468652d4d45414e2d537461636b2f696d672f6e6f64656a732d617263682d7070742e706e67" target="_blank" rel="noopener"><img src="https://camo.githubusercontent.com/233315761d49d4c75fe7969e36bda22ecf5bbc0f/687474703a2f2f6a6f616f7073696c76612e6769746875622e696f2f74616c6b732f456e642d746f2d456e642d4a6176615363726970742d776974682d7468652d4d45414e2d537461636b2f696d672f6e6f64656a732d617263682d7070742e706e67" alt=""></a></p>
<ul>
<li><strong>3. node有哪些核心模块?</strong></li>
</ul>
<p>参考答案: EventEmitter, Stream, FS, Net和全局对象</p>
<h3 id="node全局对象"><a href="#node全局对象" class="headerlink" title="node全局对象"></a><a href="https://github.com/jimuyouyou/node-interview-questions#node全局对象" target="_blank" rel="noopener"></a>node全局对象</h3><ul>
<li><strong>1. node有哪些全局对象?</strong></li>
</ul>
<p>参考答案: process, console, Buffer和exports</p>
<ul>
<li><strong>2. process有哪些常用方法?</strong></li>
</ul>
<p>参考答案: process.stdin, process.stdout, process.stderr, process.on, process.env, process.argv, process.arch, process.platform, process.exit</p>
<ul>
<li><strong>3. console有哪些常用方法?</strong></li>
</ul>
<p>参考答案: console.log/console.info, console.error/console.warning, console.time/console.timeEnd, console.trace, console.table</p>
<ul>
<li><strong>4. node有哪些定时功能?</strong></li>
</ul>
<p>参考答案: setTimeout/clearTimeout, setInterval/clearInterval, setImmediate/clearImmediate, process.nextTick</p>
<ul>
<li><strong>5. node中的事件循环是什么样子的?</strong></li>
</ul>
<p>参考答案: event loop其实就是一个事件队列，先加入先执行，执行完一次队列，再次循环遍历看有没有新事件加入队列．执行中的叫IO events, setImmediate是在当前队列立即执行,setTimout/setInterval是把执行定时到下一个队列，process.nextTick是在当前执行完，下次遍历前执行．所以总体顺序是: IO events &gt;&gt; setImmediate &gt;&gt; setTimeout/setInterval &gt;&gt; process.nextTick</p>
<ul>
<li><strong>6. node中的Buffer如何应用?</strong></li>
</ul>
<p>参考答案: Buffer是用来处理二进制数据的，比如图片，mp3,数据库文件等.Buffer支持各种编码解码，二进制字符串互转．</p>
<h3 id="EventEmitter"><a href="#EventEmitter" class="headerlink" title="EventEmitter"></a><a href="https://github.com/jimuyouyou/node-interview-questions#eventemitter" target="_blank" rel="noopener"></a>EventEmitter</h3><ul>
<li><strong>1. 什么是EventEmitter?</strong></li>
</ul>
<p>参考答案: EventEmitter是node中一个实现观察者模式的类，主要功能是监听和发射消息，用于处理多模块交互问题.</p>
<ul>
<li><strong>2. 如何实现一个EventEmitter?</strong></li>
</ul>
<p>参考答案: 主要分三步：定义一个子类，调用构造函数，继承EventEmitter</p>
<p>代码演示</p>
<pre><code>var util = require(&apos;util&apos;);
var EventEmitter = require(&apos;events&apos;).EventEmitter;

function MyEmitter() {
    EventEmitter.call(this);
} // 构造函数

util.inherits(MyEmitter, EventEmitter); // 继承

var em = new MyEmitter();
em.on(&apos;hello&apos;, function(data) {
    console.log(&apos;收到事件hello的数据:&apos;, data);
}); // 接收事件，并打印到控制台
em.emit(&apos;hello&apos;, &apos;EventEmitter传递消息真方便!&apos;);
</code></pre><ul>
<li><strong>3. EventEmitter有哪些典型应用?</strong></li>
</ul>
<p>参考答案: 1) 模块间传递消息 2) 回调函数内外传递消息 3) 处理流数据，因为流是在EventEmitter基础上实现的. 4) 观察者模式发射触发机制相关应用</p>
<ul>
<li><strong>4. 怎么捕获EventEmitter的错误事件?</strong></li>
</ul>
<p>参考答案: 监听error事件即可．如果有多个EventEmitter,也可以用domain来统一处理错误事件.</p>
<p>代码演示</p>
<pre><code>var domain = require(&apos;domain&apos;);
var myDomain = domain.create();
myDomain.on(&apos;error&apos;, function(err){
    console.log(&apos;domain接收到的错误事件:&apos;, err);
}); // 接收事件并打印
myDomain.run(function(){
    var emitter1 = new MyEmitter();
    emitter1.emit(&apos;error&apos;, &apos;错误事件来自emitter1&apos;);
    emitter2 = new MyEmitter();
    emitter2.emit(&apos;error&apos;, &apos;错误事件来自emitter2&apos;);
});
</code></pre><ul>
<li><strong>5. EventEmitter中的newListenser事件有什么用处?</strong></li>
</ul>
<p>参考答案: newListener可以用来做事件机制的反射，特殊应用，事件管理等．当任何on事件添加到EventEmitter时，就会触发newListener事件，基于这种模式，我们可以做很多自定义处理.</p>
<p>代码演示</p>
<p>var emitter3 = new MyEmitter();<br>emitter3.on(‘newListener’, function(name, listener) {<br>    console.log(“新事件的名字:”, name);<br>    console.log(“新事件的代码:”, listener);<br>    setTimeout(function(){ console.log(“我是自定义延时处理机制”); }, 1000);<br>});<br>emitter3.on(‘hello’, function(){<br>    console.log(‘hello　node’);<br>});</p>
<h3 id="Stream"><a href="#Stream" class="headerlink" title="Stream"></a><a href="https://github.com/jimuyouyou/node-interview-questions#stream" target="_blank" rel="noopener"></a>Stream</h3><ul>
<li><strong>1. 什么是Stream?</strong></li>
</ul>
<p>参考答案: stream是基于事件EventEmitter的数据管理模式．由各种不同的抽象接口组成，主要包括可写，可读，可读写，可转换等几种类型．</p>
<ul>
<li><strong>2. Stream有什么好处?</strong></li>
</ul>
<p>参考答案: 非阻塞式数据处理提升效率，片断处理节省内存，管道处理方便可扩展等.</p>
<ul>
<li><strong>3. Stream有哪些典型应用?</strong></li>
</ul>
<p>参考答案: 文件，网络，数据转换，音频视频等.</p>
<ul>
<li><strong>4. 怎么捕获Stream的错误事件?</strong></li>
</ul>
<p>参考答案: 监听error事件，方法同EventEmitter.</p>
<ul>
<li><strong>5. 有哪些常用Stream,分别什么时候使用?</strong></li>
</ul>
<p>参考答案: Readable为可被读流，在作为输入数据源时使用；Writable为可被写流,在作为输出源时使用；Duplex为可读写流,它作为输出源接受被写入，同时又作为输入源被后面的流读出．Transform机制和Duplex一样，都是双向流，区别时Transfrom只需要实现一个函数_transfrom(chunk, encoding, callback);而Duplex需要分别实现_read(size)函数和_write(chunk, encoding, callback)函数.</p>
<ul>
<li><strong>6. 实现一个Writable Stream?</strong></li>
</ul>
<p>参考答案: 三步走:1)构造函数call Writable 2)　继承Writable 3) 实现_write(chunk, encoding, callback)函数</p>
<p>代码演示</p>
<p>var Writable = require(‘stream’).Writable;<br>var util = require(‘util’);</p>
<p>function MyWritable(options) {<br>    Writable.call(this, options);<br>} // 构造函数<br>util.inherits(MyWritable, Writable); // 继承自Writable<br>MyWritable.prototype._write = function(chunk, encoding, callback) {<br>    console.log(“被写入的数据是:”, chunk.toString()); // 此处可对写入的数据进行处理<br>    callback();<br>};</p>
<p>process.stdin.pipe(new MyWritable()); // stdin作为输入源，MyWritable作为输出源 </p>
<h3 id="文件系统"><a href="#文件系统" class="headerlink" title="文件系统"></a><a href="https://github.com/jimuyouyou/node-interview-questions#文件系统" target="_blank" rel="noopener"></a>文件系统</h3><ul>
<li><strong>1. 内置的fs模块架构是什么样子的?</strong></li>
</ul>
<p>参考答案: fs模块主要由下面几部分组成: 1) POSIX文件Wrapper,对应于操作系统的原生文件操作 2) 文件流 fs.createReadStream和fs.createWriteStream 3) 同步文件读写,fs.readFileSync和fs.writeFileSync 4) 异步文件读写, fs.readFile和fs.writeFile</p>
<ul>
<li><strong>2. 读写一个文件有多少种方法?</strong></li>
</ul>
<p>参考答案: 总体来说有四种: 1) POSIX式低层读写 2) 流式读写 3) 同步文件读写 4) 异步文件读写</p>
<ul>
<li><strong>3. 怎么读取json配置文件?</strong></li>
</ul>
<p>参考答案: 主要有两种方式，第一种是利用node内置的require(‘data.json’)机制，直接得到js对象; 第二种是读入文件入内容，然后用JSON.parse(content)转换成js对象．二者的区别是require机制情况下，如果多个模块都加载了同一个json文件，那么其中一个改变了js对象，其它跟着改变，这是由node模块的缓存机制造成的，只有一个js模块对象; 第二种方式则可以随意改变加载后的js变量，而且各模块互不影响，因为他们都是独立的，是多个js对象.</p>
<ul>
<li><strong>4. fs.watch和fs.watchFile有什么区别，怎么应用?</strong></li>
</ul>
<p>参考答案: 二者主要用来监听文件变动．fs.watch利用操作系统原生机制来监听，可能不适用网络文件系统; fs.watchFile则是定期检查文件状态变更，适用于网络文件系统，但是相比fs.watch有些慢，因为不是实时机制．</p>
<h3 id="网络"><a href="#网络" class="headerlink" title="网络"></a><a href="https://github.com/jimuyouyou/node-interview-questions#网络" target="_blank" rel="noopener"></a>网络</h3><ul>
<li><strong>1. node的网络模块架构是什么样子的?</strong></li>
</ul>
<p>参考答案: node全面支持各种网络服务器和客户端，包括tcp, http/https, tcp, udp, dns, tls/ssl等.</p>
<ul>
<li><strong>2. node是怎样支持https,tls的?</strong></li>
</ul>
<p>参考答案: 主要实现以下几个步骤即可: 1) openssl生成公钥私钥 2) 服务器或客户端使用https替代http 3) 服务器或客户端加载公钥私钥证书</p>
<ul>
<li><strong>3. 实现一个简单的http服务器?</strong></li>
</ul>
<p>参考答案: 经典又很没毛意义的一个题目．思路是加载http模块，创建服务器，监听端口.</p>
<p>代码演示</p>
<pre><code>var http = require(&apos;http&apos;); // 加载http模块

http.createServer(function(req, res) {
    res.writeHead(200, {&apos;Content-Type&apos;: &apos;text/html&apos;}); // 200代表状态成功, 文档类型是给浏览器识别用的
    res.write(&apos;&lt;meta charset=&quot;UTF-8&quot;&gt; &lt;h1&gt;我是标题啊！&lt;/h1&gt; &lt;font color=&quot;red&quot;&gt;这么原生，初级的服务器，下辈子能用着吗?!&lt;/font&gt;&apos;); // 返回给客户端的html数据
    res.end(); // 结束输出流
}).listen(3000); // 绑定3ooo, 查看效果请访问 http://localhost:3000 
</code></pre><h3 id="child-process"><a href="#child-process" class="headerlink" title="child-process"></a><a href="https://github.com/jimuyouyou/node-interview-questions#child-process" target="_blank" rel="noopener"></a>child-process</h3><ul>
<li><strong>1. 为什么需要child-process?</strong></li>
</ul>
<p>参考答案: node是异步非阻塞的，这对高并发非常有效．可是我们还有其它一些常用需求，比如和操作系统shell命令交互，调用可执行文件，创建子进程进行阻塞式访问或高CPU计算等，child-process就是为满足这些需求而生的．child-process顾名思义，就是把node阻塞的工作交给子进程去做．</p>
<ul>
<li><strong>2. exec,execFile,spawn和fork都是做什么用的?</strong></li>
</ul>
<p>参考答案: exec可以用操作系统原生的方式执行各种命令，如管道 cat ab.txt | grep hello; execFile是执行一个文件; spawn是流式和操作系统进行交互; fork是两个node程序(javascript)之间时行交互.</p>
<ul>
<li><strong>3. 实现一个简单的命令行交互程序?</strong></li>
</ul>
<p>参考答案: 那就用spawn吧.</p>
<p>代码演示</p>
<pre><code>var cp = require(&apos;child_process&apos;);

var child = cp.spawn(&apos;echo&apos;, \[&apos;你好&apos;, &quot;钩子&quot;\]); // 执行命令
child.stdout.pipe(process.stdout); // child.stdout是输入流，process.stdout是输出流
// 这句的意思是将子进程的输出作为当前程序的输入流，然后重定向到当前程序的标准输出，即控制台
</code></pre><ul>
<li>4. 两个node程序之间怎样交互?</li>
</ul>
<p>参考答案: 用fork嘛，上面讲过了．原理是子程序用process.on, process.send，父程序里用child.on,child.send进行交互.<br>代码演示</p>
<pre><code>1) fork-parent.js
var cp = require(&apos;child_process&apos;);
var child = cp.fork(&apos;./fork-child.js&apos;);
child.on(&apos;message&apos;, function(msg){
    console.log(&apos;老爸从儿子接受到数据:&apos;, msg);
});
child.send(&apos;我是你爸爸，送关怀来了!&apos;);

2) fork-child.js
process.on(&apos;message&apos;, function(msg){
    console.log(&quot;儿子从老爸接收到的数据:&quot;, msg);
    process.send(&quot;我不要关怀，我要银民币！&quot;);
});
</code></pre><ul>
<li><strong>5. 怎样让一个js文件变得像linux命令一样可执行?</strong></li>
</ul>
<p>参考答案: 1) 在myCommand.js文件头部加入 #!/usr/bin/env node 2) chmod命令把js文件改为可执行即可 3) 进入文件目录，命令行输入myComand就是相当于node myComand.js了</p>
<ul>
<li><strong>6. child-process和process的stdin,stdout,stderror是一样的吗?</strong></li>
</ul>
<p>参考答案: 概念都是一样的，输入，输出，错误，都是流．区别是在父程序眼里，子程序的stdout是输入流，stdin是输出流．</p>
<h2 id="node高级话题-异步，部署，性能调优，异常调试等"><a href="#node高级话题-异步，部署，性能调优，异常调试等" class="headerlink" title="node高级话题(异步，部署，性能调优，异常调试等)"></a><a href="https://github.com/jimuyouyou/node-interview-questions#node高级话题异步部署性能调优异常调试等" target="_blank" rel="noopener"></a>node高级话题(异步，部署，性能调优，异常调试等)</h2><ul>
<li><strong>1. node中的异步和同步怎么理解</strong></li>
</ul>
<p>参考答案: node是单线程的，异步是通过一次次的循环事件队列来实现的．同步则是说阻塞式的IO,这在高并发环境会是一个很大的性能问题，所以同步一般只在基础框架的启动时使用，用来加载配置文件，初始化程序什么的．</p>
<ul>
<li><strong>2. 有哪些方法可以进行异步流程的控制?</strong></li>
</ul>
<p>参考答案: 1) 多层嵌套回调 2)　为每一个回调写单独的函数，函数里边再回调 3) 用第三方框架比方async, q, promise等</p>
<ul>
<li><strong>3. 怎样绑定node程序到80端口?</strong></li>
</ul>
<p>参考答案: 多种方式 1) sudo 2) apache/nginx代理 3) 用操作系统的firewall iptables进行端口重定向</p>
<ul>
<li><strong>4. 有哪些方法可以让node程序遇到错误后自动重启?</strong></li>
</ul>
<p>参考答案: 1) runit 2) forever 3) nohup npm start &amp;</p>
<ul>
<li><strong>5. 怎样充分利用多个CPU?</strong></li>
</ul>
<p>参考答案: 一个CPU运行一个node实例</p>
<ul>
<li><strong>6. 怎样调节node执行单元的内存大小?</strong></li>
</ul>
<p>参考答案: 用–max-old-space-size 和 –max-new-space-size 来设置 v8 使用内存的上限</p>
<ul>
<li><strong>7. 程序总是崩溃，怎样找出问题在哪里?</strong></li>
</ul>
<p>参考答案: 1) node –prof 查看哪些函数调用次数多 2) memwatch和heapdump获得内存快照进行对比，查找内存溢出</p>
<ul>
<li><strong>8. 有哪些常用方法可以防止程序崩溃?</strong></li>
</ul>
<p>参考答案: 1) try-catch-finally 2) EventEmitter/Stream error事件处理 3) domain统一控制 4) jshint静态检查 5) jasmine/mocha进行单元测试</p>
<ul>
<li><strong>9. 怎样调试node程序?</strong></li>
</ul>
<p>参考答案: node –debug app.js 和node-inspector</p>
<h2 id="常用知名第三方类库-Async-Express等"><a href="#常用知名第三方类库-Async-Express等" class="headerlink" title="常用知名第三方类库(Async, Express等)"></a><a href="https://github.com/jimuyouyou/node-interview-questions#常用知名第三方类库async-express等" target="_blank" rel="noopener"></a>常用知名第三方类库(Async, Express等)</h2><ul>
<li><strong>1. async都有哪些常用方法，分别是怎么用?</strong></li>
</ul>
<p>参考答案: async是一个js类库，它的目的是解决js中异常流程难以控制的问题．async不仅适用在node.js里，浏览器中也可以使用． 1) async.parallel并行执行完多个函数后，调用结束函数</p>
<pre><code>async.parallel(\[
    function(){ ... },
    function(){ ... }
\], callback);
</code></pre><p>2) async.series串行执行完多个函数后，调用结束函数</p>
<pre><code>async.series(\[
    function(){ ... },
    function(){ ... }
\]);
</code></pre><p>3) async.waterfall依次执行多个函数，后一个函数以前面函数的结果作为输入参数</p>
<pre><code>async.waterfall(\[
    function(callback) {
        callback(null, &apos;one&apos;, &apos;two&apos;);
    },
    function(arg1, arg2, callback) {
      // arg1 now equals &apos;one&apos; and arg2 now equals &apos;two&apos; 
        callback(null, &apos;three&apos;);
    },
    function(arg1, callback) {
        // arg1 now equals &apos;three&apos; 
        callback(null, &apos;done&apos;);
    }
\], function (err, result) {
    // result now equals &apos;done&apos; 
});
</code></pre><p>4) async.map异步执行多个数组，返回结果数组</p>
<pre><code>async.map(\[&apos;file1&apos;,&apos;file2&apos;,&apos;file3&apos;\], fs.stat, function(err, results){
    // results is now an array of stats for each file 
});
</code></pre><p>5) async.filter异步过滤多个数组，返回结果数组</p>
<pre><code>async.filter(\[&apos;file1&apos;,&apos;file2&apos;,&apos;file3&apos;\], fs.exists, function(results){
    // results now equals an array of the existing files 
});
</code></pre><ul>
<li><strong>2. express项目的目录大致是什么样子的</strong></li>
</ul>
<p>参考答案: app.js, package.json, bin/www, public, routes, views.</p>
<ul>
<li><strong>3. express常用函数</strong></li>
</ul>
<p>参考答案: express.Router路由组件,app.get路由定向，app.configure配置，app.set设定参数,app.use使用中间件</p>
<ul>
<li><strong>4. express中如何获取路由的参数</strong></li>
</ul>
<p>参考答案: /users/:name使用req.params.name来获取; req.body.username则是获得表单传入参数username; express路由支持常用通配符 ?, +, *, and ()</p>
<ul>
<li><strong>5. express response有哪些常用方法</strong></li>
</ul>
<p>参考答案: res.download() 弹出文件下载<br>res.end() 结束response<br>res.json() 返回json<br>res.jsonp() 返回jsonp<br>res.redirect() 重定向请求<br>res.render() 渲染模板<br>res.send() 返回多种形式数据<br>res.sendFile 返回文件<br>res.sendStatus() 返回状态</p>
<h2 id="其它相关后端常用技术-MongoDB-Redis-Apache-Nginx等"><a href="#其它相关后端常用技术-MongoDB-Redis-Apache-Nginx等" class="headerlink" title="其它相关后端常用技术(MongoDB, Redis, Apache, Nginx等)"></a><a href="https://github.com/jimuyouyou/node-interview-questions#其它相关后端常用技术mongodb-redis-apache-nginx等" target="_blank" rel="noopener"></a>其它相关后端常用技术(MongoDB, Redis, Apache, Nginx等)</h2><ul>
<li><strong>1. mongodb有哪些常用优化措施</strong></li>
</ul>
<p>参考答案: 类似传统数据库，索引和分区．</p>
<ul>
<li><strong>2. redis支持哪些功能</strong></li>
</ul>
<p>参考答案: set/get, hset/hget, publish/subscribe, expire</p>
<ul>
<li><strong>3. redis最简单的应用</strong></li>
</ul>
<p>参考答案:</p>
<pre><code>var redis = require(&quot;redis&quot;),
    client = redis.createClient();

client.set(&quot;foo_rand000000000000&quot;, &quot;some fantastic value&quot;);
client.get(&quot;foo_rand000000000000&quot;, function (err, reply) {
    console.log(reply.toString());
});
client.end();
</code></pre><ul>
<li><strong>4. apache,nginx有什么区别?</strong></li>
</ul>
<p>参考答案: 二者都是代理服务器，功能类似．apache应用简单，相当广泛．nginx在分布式，静态转发方面比较有优势．</p>

      
    </div>

    <div>
      
        

      
    </div>

    <div>
      
        
  <div style="padding: 10px 0; margin: 20px auto; width: 90%; text-align: center;">
    <div>坚持原创技术分享，您的支持将鼓励我继续创作！</div>
    <button id="rewardButton" disable="enable" onclick="var qr = document.getElementById('QR'); if (qr.style.display === 'none') {qr.style.display='block';} else {qr.style.display='none'}">
      <span>赏</span>
    </button>
    <div id="QR" style="display: none;">
      
        <div id="wechat" style="display: inline-block">
          <img id="wechat_qr" src="https://wurh.github.io/images/others/weixinshou.png" alt="华Ing WeChat Pay"/>
          <p>微信打赏</p>
        </div>
      
      
        <div id="alipay" style="display: inline-block">
          <img id="alipay_qr" src="https://wurh.github.io/images/others/alifu.png" alt="华Ing Alipay"/>
          <p>支付宝打赏</p>
        </div>
      
    </div>
  </div>


      
    </div>

    <footer class="post-footer">
      
        <div class="post-tags">
          
            <a href="/tags/前端-知识-面试/" rel="tag">#前端 知识 面试</a>
          
        </div>
      

      
        <div class="post-nav">
          <div class="post-nav-next post-nav-item">
            
              <a href="/2019/03/31/201903311132/" rel="next" title="前端面试《第十一篇》 Node.js相关">
                <i class="fa fa-chevron-left"></i> 前端面试《第十一篇》 Node.js相关
              </a>
            
          </div>

          <div class="post-nav-prev post-nav-item">
            
              <a href="/2019/03/31/201903311205/" rel="prev" title="前端面试《第十三篇》 React">
                前端面试《第十三篇》 React <i class="fa fa-chevron-right"></i>
              </a>
            
          </div>
        </div>
      

      
      
    </footer>
  </article>



    <div class="post-spread">
      
        
<script>
  with(document)0[(getElementsByTagName('head')[0]||body).appendChild(createElement('script')).src='//bdimg.share.baidu.com/static/api/js/share.js?cdnversion='+~(-new Date()/36e5)];
</script>

      
    </div>
  </div>


          </div>
          


          
  <div class="comments" id="comments">
    
      <div class="ds-thread" data-thread-key="2019/03/31/201903311151/"
           data-title="前端面试《第十二篇》侧重后端应用与对Node核心的理解" data-url="http://wurh.github.io/2019/03/31/201903311151/">
      </div>
    
  </div>


        </div>
        
          
  
  <div class="sidebar-toggle">
    <div class="sidebar-toggle-line-wrap">
      <span class="sidebar-toggle-line sidebar-toggle-line-first"></span>
      <span class="sidebar-toggle-line sidebar-toggle-line-middle"></span>
      <span class="sidebar-toggle-line sidebar-toggle-line-last"></span>
    </div>
  </div>

  <aside id="sidebar" class="sidebar">
    <div class="sidebar-inner">

      

      
        <ul class="sidebar-nav motion-element">
          <li class="sidebar-nav-toc sidebar-nav-active" data-target="post-toc-wrap" >
            Table of Contents
          </li>
          <li class="sidebar-nav-overview" data-target="site-overview">
            Overview
          </li>
        </ul>
      

      <section class="site-overview sidebar-panel ">
        <div class="site-author motion-element" itemprop="author" itemscope itemtype="//schema.org/Person">
          <img class="site-author-image" itemprop="image"
               src="https://wurh.github.io/images/avatar/logo.jpg?123456"
               alt="华Ing" />
          <p class="site-author-name" itemprop="name">华Ing</p>
          <p class="site-description motion-element" itemprop="description">harder and harder</p>
        </div>
        <nav class="site-state motion-element">
          <div class="site-state-item site-state-posts">
            <a href="/archives">
              <span class="site-state-item-count">56</span>
              <span class="site-state-item-name">posts</span>
            </a>
          </div>

          
            <div class="site-state-item site-state-categories">
              <a href="/categories">
                <span class="site-state-item-count">11</span>
                <span class="site-state-item-name">categories</span>
              </a>
            </div>
          

          
            <div class="site-state-item site-state-tags">
              <a href="/tags">
                <span class="site-state-item-count">15</span>
                <span class="site-state-item-name">tags</span>
              </a>
            </div>
          

        </nav>

        

        <div class="links-of-author motion-element">
          
            
              <span class="links-of-author-item">
                <a href="https://github.com/wurh" target="_blank" title="GitHub">
                  
                    <i class="fa fa-fw fa-github"></i>
                  
                  GitHub
                </a>
              </span>
            
              <span class="links-of-author-item">
                <a href="http://weibo.com/1674582564/profile?topnav=1&wvr=6" target="_blank" title="微博">
                  
                    <i class="fa fa-fw fa-globe"></i>
                  
                  微博
                </a>
              </span>
            
              <span class="links-of-author-item">
                <a href="https://www.zhihu.com/people/wu-rong-hua-56" target="_blank" title="知乎">
                  
                    <i class="fa fa-fw fa-globe"></i>
                  
                  知乎
                </a>
              </span>
            
          
        </div>

        
        

        
        
          <div class="links-of-blogroll motion-element links-of-blogroll-inline">
            <div class="links-of-blogroll-title">
              <i class="fa  fa-fw fa-globe"></i>
              Links
            </div>
            <ul class="links-of-blogroll-list">
              
                <li class="links-of-blogroll-item">
                  <a href="http://fsiaonma.github.io/" title="sam博客" target="_blank">sam博客</a>
                </li>
              
                <li class="links-of-blogroll-item">
                  <a href="http://shenjoel.github.io/" title="joel博客" target="_blank">joel博客</a>
                </li>
              
                <li class="links-of-blogroll-item">
                  <a href="http://firewood1122.github.io" title="firewood博客" target="_blank">firewood博客</a>
                </li>
              
                <li class="links-of-blogroll-item">
                  <a href="http://reqianduan.com" title="热前端" target="_blank">热前端</a>
                </li>
              
                <li class="links-of-blogroll-item">
                  <a href="http://opentutorial.info/" title="黄超博客" target="_blank">黄超博客</a>
                </li>
              
            </ul>
          </div>
        

      </section>

      
        <section class="post-toc-wrap motion-element sidebar-panel sidebar-panel-active">
          <div class="post-toc">
            
              
            
            
              <div class="post-toc-content"><ol class="nav"><li class="nav-item nav-level-1"><a class="nav-link" href="#node开发技能图解"><span class="nav-number">1.</span> <span class="nav-text">node开发技能图解</span></a></li><li class="nav-item nav-level-1"><a class="nav-link" href="#起源"><span class="nav-number">2.</span> <span class="nav-text">起源</span></a></li><li class="nav-item nav-level-1"><a class="nav-link" href="#目标与原则"><span class="nav-number">3.</span> <span class="nav-text">目标与原则</span></a></li><li class="nav-item nav-level-1"><a class="nav-link" href="#内容大纲"><span class="nav-number">4.</span> <span class="nav-text">内容大纲</span></a><ol class="nav-child"><li class="nav-item nav-level-2"><a class="nav-link" href="#javascript高级话题-面向对象，作用域，闭包，设计模式等"><span class="nav-number">4.1.</span> <span class="nav-text">javascript高级话题(面向对象，作用域，闭包，设计模式等)</span></a></li><li class="nav-item nav-level-2"><a class="nav-link" href="#node核心内置类库-事件，流，文件，网络等"><span class="nav-number">4.2.</span> <span class="nav-text">node核心内置类库(事件，流，文件，网络等)</span></a><ol class="nav-child"><li class="nav-item nav-level-3"><a class="nav-link" href="#node概览"><span class="nav-number">4.2.1.</span> <span class="nav-text">node概览</span></a></li><li class="nav-item nav-level-3"><a class="nav-link" href="#node全局对象"><span class="nav-number">4.2.2.</span> <span class="nav-text">node全局对象</span></a></li><li class="nav-item nav-level-3"><a class="nav-link" href="#EventEmitter"><span class="nav-number">4.2.3.</span> <span class="nav-text">EventEmitter</span></a></li><li class="nav-item nav-level-3"><a class="nav-link" href="#Stream"><span class="nav-number">4.2.4.</span> <span class="nav-text">Stream</span></a></li><li class="nav-item nav-level-3"><a class="nav-link" href="#文件系统"><span class="nav-number">4.2.5.</span> <span class="nav-text">文件系统</span></a></li><li class="nav-item nav-level-3"><a class="nav-link" href="#网络"><span class="nav-number">4.2.6.</span> <span class="nav-text">网络</span></a></li><li class="nav-item nav-level-3"><a class="nav-link" href="#child-process"><span class="nav-number">4.2.7.</span> <span class="nav-text">child-process</span></a></li></ol></li><li class="nav-item nav-level-2"><a class="nav-link" href="#node高级话题-异步，部署，性能调优，异常调试等"><span class="nav-number">4.3.</span> <span class="nav-text">node高级话题(异步，部署，性能调优，异常调试等)</span></a></li><li class="nav-item nav-level-2"><a class="nav-link" href="#常用知名第三方类库-Async-Express等"><span class="nav-number">4.4.</span> <span class="nav-text">常用知名第三方类库(Async, Express等)</span></a></li><li class="nav-item nav-level-2"><a class="nav-link" href="#其它相关后端常用技术-MongoDB-Redis-Apache-Nginx等"><span class="nav-number">4.5.</span> <span class="nav-text">其它相关后端常用技术(MongoDB, Redis, Apache, Nginx等)</span></a></li></ol></li></ol></div>
            
          </div>
        </section>
      

    </div>
  </aside>


        
      </div>
    </main>

    <footer id="footer" class="footer">
      <div class="footer-inner">
        <div class="copyright" >
  
  &copy;  2013 - 
  <span itemprop="copyrightYear">2019</span>
  <span class="with-love">
    <i class="fa fa-heart"></i>
  </span>
  <span class="author" itemprop="copyrightHolder">华Ing</span>
</div>

<div class="powered-by">
  Powered by <a class="theme-link" href="https://hexo.io">Hexo</a>
</div>

<div class="theme-info">
  Theme -
  <a class="theme-link" href="https://github.com/iissnan/hexo-theme-next">
    NexT.Pisces
  </a>
</div>

        

        
      </div>
    </footer>

    <div class="back-to-top">
      <i class="fa fa-arrow-up"></i>
    </div>
  </div>

  

<script type="text/javascript">
  if (Object.prototype.toString.call(window.Promise) !== '[object Function]') {
    window.Promise = null;
  }
</script>









  



  
  <script type="text/javascript" src="/lib/jquery/index.js?v=2.1.3"></script>

  
  <script type="text/javascript" src="/lib/fastclick/lib/fastclick.min.js?v=1.0.6"></script>

  
  <script type="text/javascript" src="/lib/jquery_lazyload/jquery.lazyload.js?v=1.9.7"></script>

  
  <script type="text/javascript" src="/lib/velocity/velocity.min.js?v=1.2.1"></script>

  
  <script type="text/javascript" src="/lib/velocity/velocity.ui.min.js?v=1.2.1"></script>

  
  <script type="text/javascript" src="/lib/fancybox/source/jquery.fancybox.pack.js?v=2.1.5"></script>


  


  <script type="text/javascript" src="/js/src/utils.js?v=5.0.2"></script>

  <script type="text/javascript" src="/js/src/motion.js?v=5.0.2"></script>



  
  


  <script type="text/javascript" src="/js/src/affix.js?v=5.0.2"></script>

  <script type="text/javascript" src="/js/src/schemes/pisces.js?v=5.0.2"></script>



  
  <script type="text/javascript" src="/js/src/scrollspy.js?v=5.0.2"></script>
<script type="text/javascript" src="/js/src/post-details.js?v=5.0.2"></script>



  


  <script type="text/javascript" src="/js/src/bootstrap.js?v=5.0.2"></script>



  

  
    
  

  <script type="text/javascript">
    var duoshuoQuery = {short_name:"wurh"};
    (function() {
      var ds = document.createElement('script');
      ds.type = 'text/javascript';ds.async = true;
      ds.id = 'duoshuo-script';
      ds.src = (document.location.protocol == 'https:' ? 'https:' : 'http:') + '//static.duoshuo.com/embed.js';
      ds.charset = 'UTF-8';
      (document.getElementsByTagName('head')[0]
      || document.getElementsByTagName('body')[0]).appendChild(ds);
    })();
  </script>

  
    
    <script src="/lib/ua-parser-js/dist/ua-parser.min.js?v=0.7.9"></script>
    <script src="/js/src/hook-duoshuo.js"></script>
  






  
  

  

  

  

  


</body>
</html>
